<?php

// El modelo -sólo- es cargado por
// la capa de autentificación.
//


class Auth extends UserLib
{
	private $link;
	private $crypto;

	private $loggedOn     = null;
	private $userServices = null;

	public function __construct()
	{
		if ( self::$instance == null )
		{
			// Sólo se permite una instancia de Auth, y
			// dicha instancia sólo puede crearla Auth.
			//
			self::$instance = $this;
		}
		else {
			return( self::$instance );
		}

		if ( ContextLoader::getInstace()->application->loadModel() )
		{
			$this->link   = Link::getCatalog(); // Utiliza la BD predeterminada.
			$this->crypto = new Crypto();
		}
	}


	public function validateUser($userName, $passwd)
	{
		$user    = $this->link->users->userAuthenticate($userName, $passwd);
		$success = ($user ? true : false);

		$this->getSession()->currentUser = $user;

		return($success);
	}

	/**
	 * Verifica que el usuario esté autentificado en la sesión.
	 */
	public function validateSession()
	{
		$userId = $this->getSession()->currentUser->uid;
		$ekey   = $this->getSession()->currentUser->ekey;
//throw new UnhandledException("test", $userId);
		$user = $this->link->users->getUserById( $userId );

		if ( $this->link->users->getUserById( $userId, $ekey ) )
		{
			return(true);
		}

		return(false);
	}

	public function getCurrentUser()
	{
		if ( !$this->validateSession() ) {
			return(null);
		}

		$passwd = Crypto::decrypt($data, Session::$sid);

		$user = $this->link->users->getUser(
			Session::$context->username, $passwd
		);

		return( $user );
	}

	public static function userLogged()
	{
		if ( !Session::$context->passwd ||
			 !Session::$context->username )
			return(false);

		return(true);
	}

	/**
	 * Devuelve todos los servicios que corresponden al
	 * usuario logueado, y también los compartidos.
	 */
	public function getUserServices()
	{
		// Cachea la lista de servicios de usuario.
		//
		if ( $this->userServices )
		{
			return($this->userServices);
		}

		$data   = base64_decode( Session::$context->passwd );
		$passwd = Crypto::decrypt($data, Session::$sid);

		$svcUsr = $this->link->services->getServices( Session::$context->username, $passwd );
		$svc    = $this->link->services->getServices();

		if ( !is_array($svc) )
			$svc = array($svc);

		if ( !is_array($svcUsr) )
			$svcUsr = array($svcUsr);

		$svc = array_merge($svc, $svcUsr);

		if ( !$this->userServices )
		{
			$this->userServices = $svc;

			Session::$context->userServices = $svc;
		}

		return( $svc );
	}

	public function getPublicServices()
	{
		$svc = $this->link->services->getPublicServices();

		return( $svc );
	}

	public function getModel()
	{
		return( $this->link );
	}

	public static function identify()
	{
		for( $i = 0; $i < count(ContextConfig::$allowedDomains); $i++ )
		{
			if ( ContextConfig::$allowedDomains[$i] == $_SERVER['HTTP_HOST'] ) {
				return(true);
			}
		}

		return(false);
	}

	public static function userHasService( $section )
	{

		if ( !self::userLogged() ) {
			$services = self::getInstance()->getPublicServices();
		}
		else {

			if ( !self::getInstance()->link->services->isService( $section ) )
				return( 1 );
			else
				$services = self::getInstance()->getUserServices();
		}

		foreach ( $services as $item )
		{
			if ( !is_object($item) )
				continue;

			if ( $item->service() == $section )
				return( 1 );
		}

		if ( !self::userLogged() ) {
			// Usuario desconectado.
			//
			return( -1 );
		}

		return( false );
	}

}
?>
